{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a59d13ce-40aa-4f72-b9df-ba3d60f1cb2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Sequence\n",
    "import math\n",
    "\n",
    "import numpy as np\n",
    "from numpy.typing import NDArray\n",
    "from numpy import (pi, sin, cos, sqrt, conj,\n",
    "\t\t\t\t   real as Re, trace as Tr, abs as Abs)\n",
    "from scipy.optimize import minimize\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "I, sx, sy, sz = np.identity(2, dtype=complex), np.array([[0, 1], [1, 0]], dtype=complex), np.array(\n",
    "\t\t[[0, -1.j], [1.j, 0.]]), np.diag([1., -1]).astype(complex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "930ae33d-76c1-4bce-b4f4-d9087c9723ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Gaussian_Legendre(level: int, sym: bool = False) -> tuple[NDArray, NDArray]:\n",
    "\tmatch level:\n",
    "\t\tcase 1:\n",
    "\t\t\tabscissas = [0.00000000]\n",
    "\t\t\tweights = [1.00000000e+0]\n",
    "\t\tcase 2:\n",
    "\t\t\tabscissas = [2.88675135e-1]\n",
    "\t\t\tweights = [5.00000000e-1]\n",
    "\t\tcase 3:\n",
    "\t\t\tabscissas = [0.00000000e-1, 3.87298335e-1]\n",
    "\t\t\tweights = [4.44444444e-1, 2.77777778e-1]\n",
    "\t\tcase 4:\n",
    "\t\t\tabscissas = [1.69990522e-1, 4.30568156e-1]\n",
    "\t\t\tweights = [3.26072577e-1, 1.73927423e-1]\n",
    "\t\tcase 5:\n",
    "\t\t\tabscissas = [0.00000000e-1, 2.69234655e-1, 4.53089923e-1]\n",
    "\t\t\tweights = [2.84444444e-1, 2.39314335e-1, 1.18463443e-1]\n",
    "\t\tcase 6:\n",
    "\t\t\tabscissas = [1.19309593e-1, 3.30604693e-1, 4.66234757e-1]\n",
    "\t\t\tweights = [2.33956967e-1, 1.80380787e-1, 8.56622462e-2]\n",
    "\t\tcase 7:\n",
    "\t\t\tabscissas = [0.00000000e-1, 2.02922576e-1, 3.70765593e-1, 4.74553956e-1]\n",
    "\t\t\tweights = [2.08979592e-1, 1.90915025e-1, 1.39852696e-1, 6.47424831e-2]\n",
    "\t\tcase 8:\n",
    "\t\t\tabscissas = [0.91717321e-1, 2.62766205e-1, 3.98333239e-1, 4.80144928e-1]\n",
    "\t\t\tweights = [1.81341892e-1, 1.56853323e-1, 1.11190517e-1, 5.06142681e-2]\n",
    "\t\tcase 9:\n",
    "\t\t\tabscissas = [0.00000000e-1, 1.62126712e-1, 3.06685716e-1, 4.18015554e-1, 4.84080120e-1]\n",
    "\t\t\tweights = [1.65119678e-1, 1.56173539e-1, 1.30305348e-1, 9.03240803e-2, 4.06371942e-2]\n",
    "\t\tcase 10:\n",
    "\t\t\tabscissas = [0.74437169e-1, 2.16697697e-1, 3.39704784e-1, 4.32531683e-1, 4.86953264e-1]\n",
    "\t\t\tweights = [1.47762112e-1, 1.34633360e-1, 1.09543181e-1, 7.47256746e-2, 3.33356722e-2]\n",
    "\t\tcase 11:\n",
    "\t\t\tabscissas = [0.00000000e-1, 1.34771578e-1, 2.59548065e-1, 3.65076003e-1, 4.43531300e-1, 4.89114329e-1]\n",
    "\t\t\tweights = [1.36462543e-1, 1.31402272e-1, 1.16596882e-1, 9.31451055e-2, 6.27901847e-2, 2.78342836e-2]\n",
    "\t\tcase 12:\n",
    "\t\t\tabscissas = [0.62616704e-1, 1.83915749e-1, 2.93658977e-1, 3.84951337e-1, 4.52058628e-1, 4.90780317e-1]\n",
    "\t\t\tweights = [1.24573523e-1, 1.16746268e-1, 1.01583713e-1, 8.00391643e-2, 5.34696630e-2, 2.35876682e-2]\n",
    "\t\tcase _:\n",
    "\t\t\traise NotImplementedError(\"maximum supported value of 'level' is 12\")\n",
    "\tabscissas, weights = np.asarray(abscissas), np.asarray(weights)\n",
    "\tif sym:\n",
    "\t\tif level % 2 == 1:\n",
    "\t\t\tabscissas = np.insert(abscissas, 0, -abscissas[:0:-1])\n",
    "\t\t\tweights = np.insert(weights, 0, weights[:0:-1])\n",
    "\t\telse:\n",
    "\t\t\tabscissas = np.insert(abscissas, 0, -abscissas[::-1])\n",
    "\t\t\tweights = np.insert(weights, 0, weights[::-1])\n",
    "\treturn abscissas, weights\n",
    "\n",
    "def kron_prod(level_seq: Sequence[int], sym: bool = False, quad_type: str = 'uniform') -> tuple[NDArray, NDArray]:\n",
    "\tmatch quad_type.lower():\n",
    "\t\tcase 'legendre' | 'uniform':\n",
    "\t\t\tquad_func = Gaussian_Legendre\n",
    "\t\tcase _:\n",
    "\t\t\tquad_func = Gaussian_Hermite\n",
    "\tnodes, weights = quad_func(level_seq[0], sym=sym)\n",
    "\tnodes = np.expand_dims(nodes, axis=0)\n",
    "\tfor i in range(1, len(level_seq)):\n",
    "\t\tnext_node, next_weight = quad_func(level_seq[i], sym=sym)\n",
    "\t\tnodes = np.vstack((np.kron(nodes, np.ones_like(next_node)),\n",
    "\t\t\t\t\t\t   np.kron(np.ones(nodes.shape[1]), next_node)))\n",
    "\t\tweights = np.kron(weights, next_weight)\n",
    "\treturn nodes.T, weights\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8a7d7e93-13cc-462a-896b-860747b99ba5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_infide_grad_func(infide_type: str, **kwargs):\n",
    "\tmatch infide_type.lower():\n",
    "\t\tcase 'norm2':\n",
    "\t\t\tinfide_func = lambda U1, U2: np.clip(Re(Tr((U1 - U2).T.conj() @ (U1 - U2))), 1e-12, np.inf)\n",
    "\t\t\tgrad_func = lambda U1, U2, dU2_dparam: -2.0 * Re(Tr(U1.T.conj() @ dU2_dparam))\n",
    "\t\tcase 'norm phase2':\n",
    "\t\t\traise NotImplementedError\n",
    "\t\tcase 'corr2' | 'pop2':\n",
    "\t\t\tP = np.array([[1.0, 0.0], [0, 0]], dtype=complex) if infide_type.lower() == 'pop2' \\\n",
    "\t\t\t\telse kwargs.get('P', I)\n",
    "\t\t\tinfide_func = lambda U1, U2: np.clip(1.0 - Abs(Tr(P @ U1.T.conj() @ U2) / Tr(P)) ** 2, 1e-12, 1.0)\n",
    "\t\t\tgrad_func = lambda U1, U2, dU2_dparam: -2.0 / Abs(Tr(P)) ** 2 * Re(\n",
    "\t\t\t\t\tconj(Tr(P @ U1.T.conj() @ U2)) * Tr(P @ U1.T.conj() @ dU2_dparam))\n",
    "\t\tcase 'pop2 zphase':\n",
    "\t\t\tdef infide_func(U1: NDArray, U2: NDArray):\n",
    "\t\t\t\tU = U1.T.conj() @ U2\n",
    "\t\t\t\tz_phase = np.angle(U[0, 0]) - np.angle(U[1, 1])\n",
    "\t\t\t\tUz = cos(z_phase / 2) * I - 1.j * sin(z_phase / 2) * sz\n",
    "\t\t\t\treturn np.clip(1.0 - Abs(Tr(U1.T.conj() @ U2 @ Uz) / 2) ** 2, 1e-12, 1.0)\n",
    "\n",
    "\t\t\tdef grad_func(U1: NDArray, U2: NDArray, dU2_dparam: NDArray):\n",
    "\t\t\t\tU = U2 @ U1.T.conj()\n",
    "\t\t\t\tdU_dparam = dU2_dparam @ U1.T.conj()\n",
    "\t\t\t\tdiag0, diag1 = np.diag(U)\n",
    "\t\t\t\tdiag0_dparam, diag1_dparam = np.diag(dU_dparam)\n",
    "\t\t\t\treturn -1.0 / 4 * 2 * Re(diag0_dparam * diag0.conj() + diag1_dparam * diag1.conj())\n",
    "\t\tcase _:\n",
    "\t\t\traise ValueError\n",
    "\treturn infide_func, grad_func\n",
    "    \n",
    "def get_zphase(thetas, phis, UF):\n",
    "\tUf = I.copy()\n",
    "\tfor theta, phi in zip(thetas, phis):\n",
    "\t\th_theta = theta / 2.0\n",
    "\t\tUf = (cos(h_theta) * I - 1.j * sin(h_theta) * (cos(phi) * sx + sin(phi) * sy)) @ Uf\n",
    "\tUtmp = UF.T.conj() @ Uf\n",
    "\tz_phase = np.angle(Utmp[0, 0]) - np.angle(Utmp[1, 1])\n",
    "\treturn z_phase\n",
    "    \n",
    "def egoat(\n",
    "\t\tthetas0: NDArray,\n",
    "\t\tphis0: NDArray,\n",
    "\t\tUT: NDArray,  # target unitary operator\n",
    "\t\tquad_level: int | Sequence[int],\n",
    "\t\tmax_ple: float = 0.2,\n",
    "\t\tmax_ore: float = 0.2,  # in unit of w_max\n",
    "\t\tquad_type: str = 'uniform',\n",
    "\t\tinfide_type: str = 'norm2',\n",
    "\n",
    "\t\titers: int = 300,\n",
    "\t\tangle_mod: bool = True,\n",
    "\t\tpulse_len_penalty: float = 0.0,\n",
    "\t\tverbose: bool = True,\n",
    "\t\tmethod: str = 'L-BFGS-B',\n",
    "\t\toptions: dict = None,\n",
    "\t\t**kwargs\n",
    "):\n",
    "\tassert (num_pulses := len(thetas0)) == len(phis0)\n",
    "\t\"\"\"get infidelity\"\"\"\n",
    "\tinfide_func, grad_func = get_infide_grad_func(infide_type, **kwargs)\n",
    "\tinfide_func = kwargs.get('infide_func', infide_func)\n",
    "\tgrad_func = kwargs.get('grad_func', grad_func)\n",
    "\t\"\"\"numerical integral setting\"\"\"\n",
    "\tassert isinstance(quad_level, Sequence) and len(\n",
    "\t\t\tquad_level) == 2, \"level must be integer sequences with length 2\"\n",
    "\tnodes, weights = kron_prod(quad_level, sym=True, quad_type=quad_type)\n",
    "\tnodes *= (max_ple, max_ore)\n",
    "\n",
    "\t# evaluate mean infidelity function\n",
    "\tdef eval_infide_and_grad(params: NDArray):\n",
    "\t\tmean_infide, mean_grad = 0., np.zeros_like(params)\n",
    "\t\tfor node, weight in zip(nodes, weights):\n",
    "\t\t\tif np.isclose(weight, 0.): continue\n",
    "\t\t\tple, ore = node\n",
    "\t\t\tple_a1: float = 1.0 + ple\n",
    "\t\t\tf: float = sqrt(ple_a1 ** 2 + ore ** 2)\n",
    "\n",
    "\t\t\ttmp_grad = np.zeros_like(params)\n",
    "\t\t\tU = I.copy()\n",
    "\t\t\tfor i in range(num_pulses):\n",
    "\t\t\t\ttheta, phi = (params[i], params[num_pulses + i]) if angle_mod else (thetas0[i], params[i])\n",
    "\t\t\t\th_theta = f * theta / 2.0\n",
    "\t\t\t\tU = (cos(h_theta) * I - 1.j * sin(h_theta) * (\n",
    "\t\t\t\t\t\tple_a1 * cos(phi) * sx + ple_a1 * sin(phi) * sy + ore * sz) / f) @ U\n",
    "\t\t\tUb, Uf = U.copy(), I.copy()\n",
    "\t\t\tfor i in range(num_pulses):\n",
    "\t\t\t\ttheta, phi = (params[i], params[num_pulses + i]) if angle_mod else (thetas0[i], params[i])\n",
    "\t\t\t\th_theta = f * theta / 2.0\n",
    "\t\t\t\taxis_paulis: NDArray = (ple_a1 * cos(phi) * sx + ple_a1 * sin(phi) * sy + ore * sz) / f\n",
    "\n",
    "\t\t\t\tUi = cos(h_theta) * I - 1.j * sin(h_theta) * axis_paulis\n",
    "\t\t\t\tdUi_dtheta = f / 2 * (-sin(h_theta) * I - 1.j * cos(h_theta) * axis_paulis)\n",
    "\t\t\t\tdUi_dphi: NDArray = -1.j * sin(h_theta) * (-sin(phi) * sx + cos(phi) * sy) * ple_a1 / f\n",
    "\n",
    "\t\t\t\tUb = Ub @ Ui.T.conj()\n",
    "\t\t\t\tif angle_mod:\n",
    "\t\t\t\t\ttmp_grad[i] = grad_func(UT, U, Ub @ dUi_dtheta @ Uf)\n",
    "\t\t\t\t\ttmp_grad[num_pulses + i] = grad_func(UT, U, Ub @ dUi_dphi @ Uf)\n",
    "\t\t\t\telse: tmp_grad[i] = grad_func(UT, U, Ub @ dUi_dphi @ Uf)\n",
    "\t\t\t\tUf = Ui @ Uf\n",
    "\t\t\tinfide = infide_func(UT, U)\n",
    "\t\t\t# calculate the mean infidelity and its gradient\n",
    "\t\t\tmean_infide += weight * infide\n",
    "\t\t\tmean_grad += weight * tmp_grad\n",
    "\n",
    "\t\ttarget, grad = mean_infide, mean_grad\n",
    "\t\tif angle_mod:\n",
    "\t\t\ttarget += pulse_len_penalty * sum(params[:num_pulses])\n",
    "\t\t\tgrad[:num_pulses] += pulse_len_penalty\n",
    "\t\treturn target, grad\n",
    "\n",
    "\tif options is None: options = {}\n",
    "\tresult = minimize(\n",
    "\t\t\tfun=eval_infide_and_grad,\n",
    "\t\t\tx0=np.concatenate([thetas0, phis0]) if angle_mod else phis0,\n",
    "\t\t\tmethod=method,\n",
    "\t\t\tjac=True,\n",
    "\t\t\tbounds=[(0., 4.0 * pi)] * num_pulses + [(0., 2.0 * pi)] * num_pulses if angle_mod \\\n",
    "\t\t\t\telse [(0., 2.0 * pi)] * num_pulses,\n",
    "\t\t\toptions={\n",
    "\t\t\t\t'maxiter': iters,\n",
    "\t\t\t\t'disp'   : True if verbose else False,\n",
    "\t\t\t\t**options\n",
    "\t\t\t},\n",
    "\t\t\t**kwargs\n",
    "\t)\n",
    "\treturn result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "65c88e3e-3152-4a83-8687-62af2de4e6ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Callable\n",
    "from fractions import Fraction\n",
    "\n",
    "import matplotlib as mpl\n",
    "import matplotlib.lines as lines\n",
    "from matplotlib import ticker\n",
    "\n",
    "def Square(theta: float, phi: float, w: float, g: float, f: float) -> NDArray:\n",
    "\tT: float = theta / w\n",
    "\tw1: float = (1.0 + g) * w\n",
    "\tfactor = sqrt(w1 ** 2 + f ** 2)\n",
    "\tif np.isclose(factor, 0.0): return I.copy()\n",
    "\thalf_theta: float = factor * T / 2.0\n",
    "\treturn cos(half_theta) * I - 1.j * sin(half_theta) / factor * (sx * cos(phi) * w1 + sy * sin(phi) * w1 + f * sz)\n",
    "\n",
    "def Gauss(theta: float, phi: float, w: float, g: float, f: float, N: int = 250) -> NDArray:\n",
    "\tsigma = theta / (np.sqrt(2 * pi) * w)\n",
    "\tT = 9.0 * sigma\n",
    "\tts, dt = np.linspace(0., T, N, retstep=True)\n",
    "\tple_uc = (1.0 + g) * w * np.exp(-(ts - T / 2) ** 2 / (2 * sigma ** 2))\n",
    "\tU = I.copy()\n",
    "\tfor w1 in ple_uc:\n",
    "\t\tfactor = sqrt(w1 ** 2 + f ** 2)\n",
    "\t\tif np.isclose(factor, 0.): continue\n",
    "\t\thalf_theta: float = factor * dt / 2.0\n",
    "\t\tprop = cos(half_theta) * I - 1.j * sin(half_theta) / factor * (sx * cos(phi) * w1 + sy * sin(phi) * w1 + f * sz)\n",
    "\t\tU = prop @ U\n",
    "\treturn U\n",
    "\n",
    "def composite_pulses(thetas: NDArray, phis: NDArray) -> Callable:\n",
    "\tdef pulse(Rx: Callable, theta, phi, w: float, g: float, f: float):\n",
    "\t\twgf: (float, float, float) = (w, g, f)\n",
    "\t\tU: NDArray = I.copy()\n",
    "\t\tfor theta, phi in zip(thetas, phis): U = Rx(theta, phi, *wgf) @ U\n",
    "\t\treturn U\n",
    "\n",
    "\treturn pulse\n",
    "\n",
    "def get_infide_meas(infide_type: str = 'corr2', **kwargs):\n",
    "\tmatch infide_type.lower():\n",
    "\t\tcase 'norm2':\n",
    "\t\t\tinfide_func = lambda UF, UT: \\\n",
    "\t\t\t\tRe(Tr((UF - UT).T.conj() @ (UF - UT)))\n",
    "\t\tcase 'norm2 upto global phase':\n",
    "\t\t\tinfide_func = lambda UF, UT: Re(Tr(UF.T.conj() @ UF) + Tr(UT.T.conj() @ UT) - 2 * Abs(Tr(UF.T.conj() @ UT)))\n",
    "\t\tcase 'corr2':\n",
    "\t\t\tP = kwargs.get('P', np.identity(2, dtype=complex))\n",
    "\t\t\tinfide_func = lambda UF, UT: \\\n",
    "\t\t\t\tnp.clip(1.0 - Abs(Tr(P @ UF.T.conj() @ UT) / Tr(P)) ** 2, 1e-12, 1.0)\n",
    "\t\tcase 'corr2 upto z phase':\n",
    "\t\t\tdef infide_func(UF, UT):\n",
    "\t\t\t\tU = UF.T.conj() @ UT\n",
    "\t\t\t\tz_phase = np.angle(U[0, 0]) - np.angle(U[1, 1])\n",
    "\t\t\t\tUz = cos(z_phase / 2) * I - 1.j * sin(z_phase / 2) * sz\n",
    "\t\t\t\treturn np.clip(1.0 - Abs(Tr(UF.T.conj() @ UT @ Uz) / 2) ** 2, 1e-12, 1.0)\n",
    "\t\tcase _:\n",
    "\t\t\traise NotImplementedError\n",
    "\treturn infide_func\n",
    "\n",
    "def get_infide_mat(theta: float, phi: float, w: float, gs: NDArray, fs: NDArray, ideal_gate: Callable,\n",
    "\t\t\t\t   pulse_gate: Callable, infide_type: str = 'corr2', **kwargs) -> NDArray:\n",
    "\tinfide_mat: NDArray = np.zeros((len(fs), len(gs)))\n",
    "\tinfide_func = get_infide_meas(infide_type, **kwargs)\n",
    "\tideal_Rx: NDArray = ideal_gate(theta, phi, w, 0., 0.)\n",
    "\tfor i, g in enumerate(gs):\n",
    "\t\tfor j, f in enumerate(fs):\n",
    "\t\t\treal_Rx: NDArray = pulse_gate(theta, phi, w, g, f)\n",
    "\t\t\tinfide_mat[j, i] = infide_func(ideal_Rx, real_Rx)\n",
    "\treturn infide_mat\n",
    "\n",
    "def _plot_robust_landscape(g_mat: NDArray, f_mat: NDArray, infide_ARR: NDArray, fig=None, ax=None, cmap=None, norm=None,\n",
    "\t\t\t\t\t\t   cb=False):\n",
    "\tif fig is None: fig, ax = plt.subplots(1, 1, figsize=(2.2, 2.1), layout='constrained')\n",
    "\n",
    "\tif norm is None: norm = mpl.colors.LogNorm(1e-6, 1e-1)\n",
    "\tif cmap is None: cmap = mpl.colormaps['viridis'].reversed().resampled(100)\n",
    "\tlev_exp = np.power(10, np.linspace(-6, -1, 60))\n",
    "\n",
    "\tcts = ax.contourf(g_mat, f_mat, infide_ARR, levels=lev_exp, norm=norm, cmap=cmap, extend='both')\n",
    "\tax.contour(g_mat, f_mat, infide_ARR, levels=[1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1],\n",
    "\t\t\t   colors=['red', 'red', 'k', 'grey', 'white', 'orange'], linewidths=1.0,\n",
    "\t\t\t   linestyles=[':', '-', '--', '-', '--', ':'])\n",
    "\tif cb:\n",
    "\t\tfig.colorbar(cts, ax=ax, orientation='vertical',\n",
    "\t\t\t\t\t fraction=.05, pad=0.05, aspect=25, extend='both',\n",
    "\t\t\t\t\t ticks=[1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6],\n",
    "\t\t\t\t\t format=mpl.ticker.FixedFormatter(\n",
    "\t\t\t\t\t\t\t ['$10^{-1}$', '$10^{-2}$', '$10^{-3}$', '$10^{-4}$', '$10^{-5}$', '$10^{-6}$']))\n",
    "\n",
    "def plot_robust_landscape(theta: float, phi: float, w: float, gs: NDArray, fs: NDArray, ideal_gate: Callable,\n",
    "\t\t\t\t\t\t  pulse_gate: Callable, infide_type='corr2', fig=None, ax=None, cmap=None, norm=None,\n",
    "\t\t\t\t\t\t  cb=False, **kwargs):\n",
    "\tif fig is None: fig, ax = plt.subplots(1, 1, figsize=(2.2, 2.1), layout='constrained')\n",
    "\tg_ARR, f_ARR = np.meshgrid(gs, fs)\n",
    "\tinfide_ARR = get_infide_mat(theta, phi, w, gs, fs, ideal_gate, pulse_gate, infide_type=infide_type, **kwargs)\n",
    "\t_plot_robust_landscape(g_ARR, f_ARR, infide_ARR, fig=fig, ax=ax, cmap=cmap, norm=norm, cb=cb)\n",
    "\n",
    "def _angle2str(angle: float, precision: int = 4) -> str:\n",
    "\tangle = round(angle / pi, precision)\n",
    "\tnum, den = Fraction(str(angle)).as_integer_ratio()\n",
    "\tif den == 1:\n",
    "\t\treturn r'0' if num == 0 else r'\\pi' if num == 1 else r'-\\pi' if num == -1 else f'%s\\pi' % num\n",
    "\telif den <= 24:\n",
    "\t\treturn r'\\frac{%s}{%s}\\pi' % (num, den) if num > 0 else r'-\\frac{%s}{%s}\\pi' % (-num, den)\n",
    "\telse:\n",
    "\t\treturn f'{angle:.{precision}f}\\pi'\n",
    "\n",
    "def compare_robust_landscape(theta: float, phi: float, w: float, gs: NDArray, fs: NDArray, ideal_gate: Callable,\n",
    "\t\t\t\t\t\t\t pulse_gates: dict, infide_type='corr2', fig=None, axs=None, legend=False, **kwargs):\n",
    "\tlen_pulses: int = len(pulse_gates)\n",
    "\tif fig is None:\n",
    "\t\tfig, axs = plt.subplots(1, len_pulses, figsize=(3.4 * len_pulses, 3.5), layout='constrained')\n",
    "\tfor i, (pulse_name, pulse_gate) in enumerate(pulse_gates.items()):\n",
    "\t\tax = axs[i] if len_pulses > 1 else axs\n",
    "\t\tplot_robust_landscape(theta, phi, w, gs, fs, ideal_gate, pulse_gate, fig=fig, ax=ax,\n",
    "\t\t\t\t\t\t\t  infide_type=infide_type, cb=True if i == len_pulses - 1 else False, **kwargs)\n",
    "\t\tax.set_xlabel(r'$\\beta_\\Omega$')\n",
    "\t\tax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, pos: f'{x / w:.1f}'))\n",
    "\t\tax.set_title(pulse_name)\n",
    "\tax = axs[0] if len_pulses > 1 else axs\n",
    "\tax.set_ylabel(r'$\\beta_z/\\Omega_m$')\n",
    "\tfor i in range(1, len(pulse_gates)):\n",
    "\t\tax = axs[i] if len_pulses > 1 else axs\n",
    "\t\tax.yaxis.set_ticklabels([])\n",
    "\tif legend:\n",
    "\t\tlabels, colors, linestyles = ['$10^{-1}$', '$10^{-2}$', '$10^{-3}$', '$10^{-4}$', '$10^{-5}$'], \\\n",
    "\t\t\t['orange', 'w', 'grey', 'k', 'red'], [':', '--', '-', '--', '-']\n",
    "\t\tfig.legend(handles=[lines.Line2D([0], [0], label=label, c=c, ls=ls) for label, c, ls in\n",
    "\t\t\t\t\t\t\tzip(labels, colors, linestyles)], ncols=1, loc='lower left', facecolor='silver',\n",
    "\t\t\t\t   shadow=True)\n",
    "\tfig.suptitle(r'Robust Landscape of $\\beta_z$,$\\beta_\\Omega$ when $\\theta=%s$,$\\phi=%s$' % (_angle2str(theta), _angle2str(phi)))\n",
    "\n",
    "def repr_composite_pulse(thetas, phis, new_line=4, precision=4):\n",
    "\trepr_str = ''\n",
    "\tfor i, (theta, phi) in enumerate(zip(thetas, phis)):\n",
    "\t\ttheta_as_str, phi_as_str = _angle2str(theta, precision), _angle2str(phi, precision)\n",
    "\t\tpre_str = r\"\\rightarrow\" if i != 0 else ''\n",
    "\t\trepr_str += pre_str + r\"(%s)_{%s}\" % (theta_as_str, phi_as_str)\n",
    "\t\tif i != 0 and i % new_line == 0: repr_str += '\\n'\n",
    "\treturn repr_str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8f255a58-71d1-44f4-b995-51cf2675dcf3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  message: CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL\n",
      "  success: True\n",
      "   status: 0\n",
      "      fun: 1.4653126351409777e-05\n",
      "        x: [ 9.358e-06  1.236e+00 ...  1.236e+00  9.223e-06]\n",
      "      nit: 24\n",
      "      jac: [ 8.773e-06 -5.451e-06 ... -4.813e-06  8.827e-06]\n",
      "     nfev: 26\n",
      "     njev: 26\n",
      " hess_inv: <13x13 LbfgsInvHessProduct with dtype=float64>\n"
     ]
    }
   ],
   "source": [
    "def Rx(theta: float, phi: float):\n",
    "\treturn cos(theta / 2) * I - 1.j * sin(theta / 2) * (cos(phi) * sx + sin(phi) * sy)\n",
    "\n",
    "phis0 = np.array([0, 9, 42, 11, 8, 37, 2, 37, 8, 11, 42, 9, 0]) * pi / 24  # U13a\n",
    "thetas0 = np.ones(len(phis0)) * pi\n",
    "\n",
    "thetaT, phiT = pi, 0.\n",
    "UT = Rx(thetaT, phiT)\n",
    "w_max = 0.01 * (2 * pi)  # f=0.01·(2π)MHz, 1MHz <===> 1μs\n",
    "max_ple, max_ore, sample_num = 6e-1, 7e-1, 45\n",
    "angle_mod = False\n",
    "result = egoat(\n",
    "\t\tthetas0=thetas0,\n",
    "\t\tphis0=phis0,\n",
    "\t\tUT=UT,  # target unitary\n",
    "\t\tquad_level=[5, 5],\n",
    "\t\tmax_ple=max_ple,\n",
    "\t\tmax_ore=max_ore,  # in unit of w_max\n",
    "\t\tangle_mod=angle_mod,\n",
    "\t\tquad_type='uniform',\n",
    "\t\tinfide_type='pop2 zphase',\n",
    "\n",
    "\t\titers=2000,\n",
    "\t\toptions={\n",
    "\t\t\t'maxcor': 25,\n",
    "\t\t},\n",
    ")\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "45592650-a890-4758-8b8c-e5038f7ab89c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\begin{align}\\{\\theta_i\\}&=[\\pi, \\pi, \\pi, \\pi, \\pi, \\pi, \\pi, \\pi, \\pi, \\pi, \\pi, \\pi, \\pi]\\\\ \\{\\phi_i\\}&=[0, 0.3933\\pi, 1.7583\\pi, 0.4800\\pi, 0.3400\\pi, 1.5238\\pi, 0.0742\\pi, 1.5238\\pi, 0.3400\\pi, 0.4800\\pi, 1.7583\\pi, 0.3933\\pi, 0]\\\\ \\varphi_z&=-1.0469\\pi\\\\ \\textrm{pulses}&=(\\pi)_{0}\\rightarrow(\\pi)_{0.3933\\pi}\\rightarrow(\\pi)_{1.7583\\pi}\\rightarrow(\\pi)_{0.4800\\pi}\\rightarrow(\\pi)_{0.3400\\pi}\n",
       "\\rightarrow(\\pi)_{1.5238\\pi}\\rightarrow(\\pi)_{0.0742\\pi}\\rightarrow(\\pi)_{1.5238\\pi}\\rightarrow(\\pi)_{0.3400\\pi}\n",
       "\\rightarrow(\\pi)_{0.4800\\pi}\\rightarrow(\\pi)_{1.7583\\pi}\\rightarrow(\\pi)_{0.3933\\pi}\\rightarrow(\\pi)_{0}\n",
       " \\end{align}$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "params = result.x\n",
    "thetas_res = params[:len(thetas0)] if angle_mod else thetas0\n",
    "phis_res = params[len(thetas0):] if angle_mod else params\n",
    "zphase = get_zphase(thetas_res, phis_res, UT)\n",
    "\n",
    "from IPython.display import Latex\n",
    "\n",
    "thetas_str, phis_str = ', '.join([_angle2str(theta) for theta in thetas_res]), ', '.join([_angle2str(phi) for phi in phis_res])\n",
    "Latex(r\"$\\begin{align}\\{\\theta_i\\}&=[%s]\\\\ \\{\\phi_i\\}&=[%s]\\\\ \\varphi_z&=%s\\\\ \\textrm{pulses}&=%s \\end{align}$\" \n",
    "      % (thetas_str, phis_str, _angle2str(zphase), repr_composite_pulse(thetas_res, phis_res)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9e0a6b3b-fad6-416b-9e19-45e99f8d5d94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 680x350 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from functools import partial\n",
    "\n",
    "ple_arr, ore_arr = np.linspace(-max_ple, max_ple, sample_num), np.linspace(-max_ore, max_ore, sample_num) * w_max\n",
    "\n",
    "test_pulse_S = {\n",
    "\t'benchmark': partial(composite_pulses(thetas0, phis0), Square),\n",
    "\t'test'     : partial(composite_pulses(thetas_res, phis_res), Square),\n",
    "}\n",
    "compare_robust_landscape(thetaT, phiT, w_max, ple_arr, ore_arr, Square, test_pulse_S,\n",
    "\t\t\t\t\t\t infide_type='corr2', P=np.array([[1.0, 0.0], [0.0, 0.0]], dtype=complex))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
